/**
 * Copyright (C) 2017 - 2020 https://github.com/joewee
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.bifrost.common.util;

import com.google.common.collect.Maps;
import com.google.common.hash.Funnel;
import com.google.common.hash.HashCode;
import com.google.common.hash.HashFunction;
import com.google.common.hash.Hasher;
import com.google.common.hash.Hashing;
import com.google.common.hash.PrimitiveSink;
import com.google.common.io.Files;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.charset.Charset;
import java.util.List;
import java.util.Map;

/**
 *
 *
 *@author joewee
 *@version 1.0.0
 *@Date 2018/2/26 13:58
 */
public class MD5Utils {
    private static HashFunction hf = Hashing.md5();
    private static Charset defaultCharset = Charset.forName("UTF-8");

    private MD5Utils() {
        throw new AssertionError("不要实例化工具类哦");
    }

    public static String md5(String data) {
        HashCode hash = hf.newHasher().putString(data, defaultCharset).hash();
        return hash.toString();
    }

    public static String md5(String data, Charset charset, boolean isUpperCase) {
        HashCode hash = hf.newHasher().putString(data, charset == null ? defaultCharset : charset).hash();
        return isUpperCase ? hash.toString().toUpperCase() : hash.toString();
    }

    public static String md5(byte[] bytes, boolean isUpperCase) {
        HashCode hash = hf.newHasher().putBytes(bytes).hash();
        return isUpperCase ? hash.toString().toUpperCase() : hash.toString();
    }

    public static String md5(File sourceFile, boolean isUpperCase) {
        HashCode hash = hf.newHasher().putObject(sourceFile, new Funnel<File>() {

            private static final long serialVersionUID = 2757585325527511209L;

            @Override
            public void funnel(File from, PrimitiveSink into) {
                try {
                    into.putBytes(Files.toByteArray(from));
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }).hash();
        return isUpperCase ? hash.toString().toUpperCase() : hash.toString();
    }

    /**
     * @param object 只能是封装了数据的实体类，不可以是map，List等
     * @param fieldNames 需要参与md5计算的字段属性名，如果该属性也是一个封住数据实体类话，.后跟上具体属性名即可。如：role.level.id
     * @param isUpperCase 结果是否大写
     * @param charset 涉及到字符串时的操作编码，默认是utf-8
     * @return
     */
    public static String md5(final Object object, final List<String> fieldNames, boolean isUpperCase, final Charset charset) {
        HashCode hash = hf.newHasher().putObject(object, new Funnel<Object>() {

            private static final long serialVersionUID = -5236251432355557848L;

            @Override
            public void funnel(Object from, PrimitiveSink into) {

                Map<String, Field> allField = getAllField(object);

                for (String fieldName : fieldNames) {

                    try {
                        if (fieldName.contains(".")) {
                            handleDeepField(object, charset, into, allField, fieldName);
                        } else {
                            handleField(object, charset, into, allField, fieldName);
                        }
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            }

        }).hash();
        return isUpperCase ? hash.toString().toUpperCase() : hash.toString();
    }

    private static void handleDeepField(Object tempValue, Charset charset, PrimitiveSink into, Map<String, Field> tempAllField, String fieldName)
            throws NoSuchFieldException, IllegalAccessException {
        Field field = null;
        String[] names = fieldName.split("\\.");

        for (String name : names) {
            field = tempAllField.get(name);
            if (field == null) {
                throw new NoSuchFieldException(fieldName);
            }
            field.setAccessible(true);
            tempValue = field.get(tempValue);
            field.setAccessible(false);
            tempAllField = getAllField(tempValue);
        }

        stuffFieldValue(tempValue, charset, into);
    }

    private static void handleField(Object object, Charset charset, PrimitiveSink into, Map<String, Field> allField, String fieldName)
            throws NoSuchFieldException, IllegalAccessException {
        Field field = allField.get(fieldName);
        if (field == null) {
            throw new NoSuchFieldException(fieldName);
        }

        field.setAccessible(true);
        Object tempValue = field.get(object);
        stuffFieldValue(tempValue, charset, into);
        field.setAccessible(false);
    }

    private static void stuffFieldValue(Object value, Charset charset, PrimitiveSink into) throws IllegalAccessException {

        if (value instanceof Integer) {
            into.putInt((int) value);
        } else if (value instanceof Long) {
            into.putLong((long) value);
        } else if (value instanceof Float) {
            into.putFloat((float) value);
        } else if (value instanceof Double) {
            into.putDouble((double) value);
        } else if (value instanceof Short) {
            into.putShort((short) value);
        } else if (value instanceof Byte) {
            into.putByte((byte) value);
        } else if (value instanceof Boolean) {
            into.putBoolean((boolean) value);
        } else if (value instanceof Byte) {
            into.putByte((byte) value);
        } else if (value instanceof Character) {
            into.putChar((char) value);
        } else if (value instanceof String) {
            into.putString((String) value, charset == null ? defaultCharset : charset);
        } else {
            throw new IllegalArgumentException(value.getClass() + " is not basic data type");
        }
    }

    private static Map<String, Field> getAllField(Object object) {
        Map<String, Field> fieldMap = Maps.newHashMap();

        if (object.getClass().getName().equals(Object.class.getName())) {
            return fieldMap;
        }

        Class<?> tempClass = object.getClass();
        Field[] declaredFields = null;
        while (true) {
            declaredFields = tempClass.getDeclaredFields();
            for (Field field : declaredFields) {
                fieldMap.put(field.getName(), field);
            }

            tempClass = tempClass.getSuperclass();

            if (tempClass.getName().equals(Object.class.getName())) {
                break;
            }

        }

        return fieldMap;
    }
}

